package 异常;

import java.util.InputMismatchException;
import java.util.Scanner;

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {//我们把该编译时异常抛给调用这个方法的地方
        return super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {//不想处理就继续往上抛
        Person person = new Person("xioabao");
        Person person1 = (Person) person.clone();
    }
}

public class Test {
    public static void main9(String[] args) {

    }
    public static void main(String[] args) {
        System.out.println("before......");
        try {
            System.out.println(10/0);
            System.out.println("11234");//这里的代码不能打印
        }catch (ArithmeticException e) {//这里面的参数就是你要捕获的异常(要匹配),捕获到了才会执行catch当中的内容
           //这个玩意是使用其他工具来打印的,不是用System.out.println
            e.printStackTrace();
            System.out.println("我来处理ArithmeticException异常了");

        }catch (Exception e) {//我们可以通过catch捕获多个异常,但是同一时刻只能抛出一个异常
            System.out.println("Exception异常了");//这个相当于充当了殿后的角色
        }
        System.out.println("after......");//这个不try catch就是jvm来处理的

    }
    public static void func() throws CloneNotSupportedException {
        int a = 10;
        if(a == 10) {
//            throw  new NullPointerException("999");//TODO 通过throw手动抛出异常
            throw new CloneNotSupportedException("333");//TODO　如果是编译时异常,那么通过throws就可以忽略这个异常
        }

//        func();//这个就是Error
    }


//    public static void main2(String[] args) {//调用这个方法的,因为拿里面有编译时异常,因此也要throws交给jvm,如果不想交给jvm那么就引出了try catch
//        func();//栈溢出错误
//    }
public static void main4(String[] args) {//TODO 我们使用try catch自己进行处理
    try {
        func();//
    } catch (CloneNotSupportedException e) {
        throw new RuntimeException(e);
    }
}

    public static void main1(String[] args) {
//        System.out.println(1/0);//算数异常
        System.out.println("abcd");//当程序出现异常之后,将不会运行后面的代码
        int[] array = null;
        System.out.println(array[0]);//空指针异常
        System.out.println("abcd");//当程序出现异常之后,将不会运行后面的代码
        //上面都是Exception
        //Exception和Error都继承于Throwable
        //Error:java虚拟机无法解决严重错误,比如: JVM的内部错误,资源耗尽等:比如栈溢出
        //EXception:异常产生后程序呀可以通过代码进行处理,使程序继续执行.
        //异常的体系结构:一张图
        //Exception分为运行时异常(非抽查异常)运行的时候才查出来,必须解决了才能运行,编译时异常(受查异常)克隆CloneNotSupportException
        //总之异常就是个类

        //try{存放可能存在异常的代码}catch(捕获具体的异常){}finally{}
        //如何让程序抛出异常
        //1.某程序触发
        //2.通过关键字throw抛出异常
        //
    }

    public static void main3(String[] args) throws CloneNotSupportedException {//throws使用再方法的声明之后,告诉方法的调用这,调用这个方法会抛出***异常,

//        1. throw必须写在方法体内部
//        2. 抛出的对象必须是Exception 或者 Exception 的子类对象
//        3. 如果抛出的是 RunTimeException 或者 RunTimeException 的子类，则可以不用处理，直接交给JVM来处理
//        4. 如果抛出的是编译时异常，用户必须处理，否则无法通过编译
//        5. 异常一旦抛出，其后的代码就不会执行
        //如果一个方法内部存在一个编译时(受查异常),此时这个编译时异常一定要进行处理
        //目前我们的处理方式是 在方法定义的时候通过throws关键字申明异常
        //最后这个异常是交给JVM处理的
    }
} class TestFinally {
    public static int getData(){
        Scanner sc = null;
        try{
            sc = new Scanner(System.in);
            int data = sc.nextInt();
            return data;
        }catch (InputMismatchException e){
            e.printStackTrace();
        }finally {
            System.out.println("finally中代码");//在finally里面的代码,无论如何都会执行
        }System.out.println("try-catch-finally之后代码");
        if(null != sc){
            sc.close();//如果正常输入的话,就进不来,因此会造成资源泄露
        }
        return 0;
    }
    public static void main(String[] args) {
        int data = getData();
        System.out.println(data);
    }
}
//继承于Exception会默认是受查异常
//继承RuntimeException会默认是非受查异常